tests.toml

tests.toml should describe which tests from the canonical-data.json are implemented in the language-specific translation.
Lines 52-62 and 76-86 claim that three tests are not implemented but actually they are (lines 56-66 and 82-92).

test_list_ops.nim

The suite for foldl implements six tests (lines 55-78).
But the three latter tests are meant as replacements for the three former ones, specified via "reimplements"
(e.g. https://github.com/exercism/problem-specifications/blob/main/exercises/list-ops/canonical-data.json#L206).)
I'd suggest deleting the three tests in lines 56-66.

It's similar for the suite for foldr (lines 81-104), the latter three tests are meant as replacements for the former three tests.

The tests "empty list" in the suites for foldl (lines 68-70) and foldr (lines 94-96) define a function that adds its two parameters.
Why not stay true to the canonical-data.json and multiply the parameters?

The tests "direction dependent function applied to non-empty list" for foldl (lines 76-78 ) and foldr (lines 102-104) define a function that uses a subtraction.
The canonical-data.json uses a division and explicitly mentions in a comment that "if integer division is expected / required" the test data from the old version should be used.

The tests uses parameter names acc and el for the function that make it clear which argument is the accumulator.
see https://github.com/exercism/problem-specifications/blob/main/exercises/list-ops/canonical-data.json#L162-L165
They even reimplemented the three tests for foldl so this seems to be important.

The tests uses parameter names acc and el for the function that make it clear which argument is the accumulator.
see https://github.com/exercism/problem-specifications/blob/main/exercises/list-ops/canonical-data.json#L260-L263
They even reimplemented the three tests for foldl so this seems to be important.
I'd suggest using similarly expressive names instead of x and y.

list_ops.nim (stub)

In the initial stub the second parameter for foldl and foldr is defined as function: proc(x, y: int): int.
x and y are pretty generic names. IIRC that has confused some students and caused debates.
It was decided to rename these parameters to acc and el so that it would be obvious which one is the accumulator.
That was the reason why the three original tests for foldl and foldr were replaced.
I'd suggest using similarly expressive names instead of x and y, to stay close to the canonical-data.json and to avoid confusion.

The [canonical-data.json] contains a comment regarding the order of the arguments for the function that gets passed to foldl and foldr.
It basically says that there are different conventions, we should use the one common to the programming language.
Nim has the template foldl and foldr in the sequtils module.
foldl takes an expression where a is the accumulator and b the element,
whereas foldr takes an expression where a is the element and b is the accumulator.

I'd suggest changing the function in the "direction dependent" tests for foldr so that our foldr behaves similarly to sequtils.foldr:

do_assert sequtils.foldl(@[5, 7], a - b, 0) == -12
do_assert sequtils.foldl(@[1, 20, 300], a - b, 0) == -321
do_assert foldl(@[5, 7], func(acc, el: int): int = acc - el, 0) == -12
do_assert foldl(@[1, 20, 300], func(acc, el: int): int = acc - el, 0) == -321

do_assert sequtils.foldr(@[5, 7, 0], a - b) == -2
do_assert sequtils.foldr(@[1, 20, 300, 0], a - b) == 281
do_assert foldr(@[5, 7], func(el, acc: int): int = el - acc, 0) == -2
do_assert foldr(@[1, 20, 300], func(el, acc: int): int = el - acc, 0) == 281

example.nim

The example solution uses openArray almost everywhere for the parameters, whereas the solution stub uses seq.
Did you do that on purpose? How about openArray in the solution stub?